package com.example.myapplication.dao;

import android.annotation.SuppressLint;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

import androidx.annotation.Nullable;

import com.example.myapplication.bean.Person;
import com.example.myapplication.bean.User;

import java.util.ArrayList;
import java.util.List;

/**
 * 该类主要用于创建和管理数据库表
 */
public class MySQLiteOpenHelper extends SQLiteOpenHelper {
    public static void main(String[] args) {

    }

    private static final String DB_NAME = "address_book";

    // 人际信息表名为："tb_person"
    private static final String PERSON_TABLE_NAME = "tb_person";
    // 登录用户表名为："tb_user"
    private static final String USER_TABLE_NAME = "tb_user";
    // 人际信息表建表语句（name字段唯一）
    private static final String CREATE_TABLE_PERSON_SQL = "create table " + PERSON_TABLE_NAME + " " +
            "(person_id integer primary key autoincrement, " +
//            "name text unique, " +
            "name text unique, " +
            "sex number, " +
            "phone text, " +
            "phone2 text, " +
            "relation text, " +
            "reText text, " +
            "address text, " +
            "user_id integer, " +
            "foreign key(user_id) references " + USER_TABLE_NAME + "(user_id) on delete cascade)";
    // 登录用户表建表语句（account字段唯一）
    private static final String CREATE_TABLE_USER_SQL = "create table " + USER_TABLE_NAME + " " +
            "(user_id integer primary key autoincrement, " +
            "account text unique, " +
            "password text)";

    // 调用父类构造方法，初始化数据库
    public MySQLiteOpenHelper(@Nullable Context context, @Nullable String name, @Nullable SQLiteDatabase.CursorFactory factory, int version) {
        super(context, name, factory, version);
    }

    // 提供一个默认的构造方法，使用固定的数据库名 "address_book" 和版本号 1
    public MySQLiteOpenHelper(Context context) {
        super(context, DB_NAME, null, 1);
    }

    // 当数据库第一次被创建时调用，创建人际信息表tb_person和登录用户表tb_user。
    @Override
    public void onCreate(SQLiteDatabase db) {
        // 创建人际信息表tb_person
        db.execSQL(CREATE_TABLE_PERSON_SQL);
        // 创建登录用户表tb_user
        db.execSQL(CREATE_TABLE_USER_SQL);
    }

    /**
     * 新增人际信息
     * @param person
     * @return
     */
    public boolean insertPerson(Person person) {
        // 获取可读写的数据库实例
        SQLiteDatabase db = getWritableDatabase();
        // 创建ContentValues对象，用于存储要插入的数据
        ContentValues contentValues = new ContentValues();
        // 将User对象的数据添加到ContentValues对象中
        contentValues.put("name", person.getName());
        contentValues.put("sex", person.getSex());
        contentValues.put("phone", person.getPhone());
        contentValues.put("phone2", person.getPhone2());
        contentValues.put("relation", person.getRelation());
        contentValues.put("reText", person.getReText());
        contentValues.put("address", person.getAddress());
        contentValues.put("user_id", person.getUserId());
        // 执行插入操作，返回插入的行ID
        long insertId = db.insert(PERSON_TABLE_NAME, null, contentValues);
        // 检查插入操作是否成功
        return insertId > 0;
    }

    /**
     * 根据条件查询人际信息
     *
     * @param i         查询类型 （0无条件，1按姓名，5按关系）
     * @param nameParam 条件：姓名
     * @param relationParam 条件：关系（1家人，2朋友，3师生，4同事，5#其他(备注)，-1陌生人(未定义)）
     * @return List<Person>
     */
    public List<Person> queryPersonByCondition(int i, String nameParam, Integer relationParam, Integer userId) {
        // 获取只读的数据库连接实例
        SQLiteDatabase db = getReadableDatabase();
        // 创建一个Person列表，用于存储查询结果
        List<Person> personList = new ArrayList<>();
        // 根据不同的查询类型，执行相应的查询操作
        Cursor cursor = null;
        switch (i) {
            // 0无条件：查询表中所有数据
            case 0:
                cursor = db.query(PERSON_TABLE_NAME, null, "user_id = ?", new String[]{userId.toString()}, null, null, null);
                break;
            // 1按姓名：根据姓名进行模糊查询
            case 1:
                nameParam = "%" + nameParam + "%";
                cursor = db.query(PERSON_TABLE_NAME, null, "name LIKE ? AND user_id = ?", new String[]{nameParam, userId.toString()}, null, null, null);
                break;
            // 5按关系：根据关系进行模糊查询
            case 5:
                // 1家人，2朋友，3师生，4同事，5#其他(备注)，-1陌生人(未定义)
                String relation = relationParam.equals(1) ? relationParam + "%" : "%" + relationParam + "%" ;
                cursor = db.query(PERSON_TABLE_NAME, null, "relation LIKE ? AND user_id = ?", new String[]{relation, userId.toString()}, null, null, null);
                break;
            default:
        }
        // 遍历游标，将查询结果添加到Person列表中
        if (cursor != null) {
            // 循环遍历游标，获取每一行的数据
            while (cursor.moveToNext()) {
                @SuppressLint("Range") String name = cursor.getString(cursor.getColumnIndex("name"));
                @SuppressLint("Range") int sex = cursor.getInt(cursor.getColumnIndex("sex"));
                @SuppressLint("Range") String phone = cursor.getString(cursor.getColumnIndex("phone"));
                @SuppressLint("Range") String phone2 = cursor.getString(cursor.getColumnIndex("phone2"));
                @SuppressLint("Range") String relation = cursor.getString(cursor.getColumnIndex("relation"));
                @SuppressLint("Range") String reText = cursor.getString(cursor.getColumnIndex("reText"));
                @SuppressLint("Range") String address = cursor.getString(cursor.getColumnIndex("address"));
                // 创建Person对象，并将查询结果赋值给Person对象
                Person person = new Person();
                person.setName(name);
                person.setSex(sex);
                person.setPhone(phone);
                person.setPhone2(phone2);
                person.setRelation(relation);
                person.setReText(reText);
                person.setAddress(address);
                // 将Person对象添加到列表中
                personList.add(person);
            }
            // 关闭游标
            cursor.close();
        }
        // 返回Person列表
        return personList;
    }

    /**
     * 根据联系人姓名更新人际信息
     *
     * @param person
     * @param name
     * @return
     */
    public boolean updatePerson(Person person, String name) {
        // 获取可读写的数据库连接实例
        SQLiteDatabase db = getWritableDatabase();
        // 创建ContentValues对象，用于存储要更新的数据
        ContentValues contentValues = new ContentValues();
        // 将User对象的数据添加到ContentValues对象中
        contentValues.put("name", person.getName());
        contentValues.put("sex", person.getSex());
        contentValues.put("phone", person.getPhone());
        contentValues.put("phone2", person.getPhone2());
        contentValues.put("relation", person.getRelation());
        contentValues.put("reText", person.getReText());
        contentValues.put("address", person.getAddress());
        // 执行更新操作，返回更新的行数
        return db.update(PERSON_TABLE_NAME, contentValues, "name = ?", new String[]{name}) > 0;
    }

    /**
     * 预查询数据的个数
     * @param nameParam 条件：姓名
     * @param userId 条件：用户id
     * @return
     */
    public int queryCount(String nameParam, Integer userId) {
        // 获取只读的数据库连接实例
        SQLiteDatabase db = getReadableDatabase();
        // 设置模糊查询的列名为 name，并构建模糊匹配的值 value
        String column = "name";
        String value = "%" + nameParam + "%";
        // 构建查询语句
        String queryCount = "SELECT COUNT(*) FROM " + PERSON_TABLE_NAME + " WHERE " + column + " LIKE ?" + " AND user_id = ?";
        // 使用rawQuery方法执行查询，返回一个Cursor对象
        Cursor cursor = db.rawQuery(queryCount, new String[]{value, userId.toString()});
        // 获取查询结果
        int count = 0;
        // 移动Cursor到第一个位置，获取查询结果的第一列的值，即记录总数
        if (cursor.moveToFirst()) {
            count = cursor.getInt(0);
        }
        // 关闭Cursor对象，释放资源。
        cursor.close();
        // 返回记录总数
        return count;
    }

    /**
     * 根据联系人姓名删除联系人
     * 根据userId删除该用户下的所有联系人
     *
     * @param person 联系人信息，其中包括待删除的联系人姓名、或者所属用户id
     * @return
     */
    public boolean deletePerson(Person person) {
        // 获取可读写的数据库连接实例
        SQLiteDatabase db = getWritableDatabase();
        // 构建一个删除条件字符串，使用 name、sex 和 phone 作为匹配条件
        String name = person.getName();
        Integer userId = person.getUserId();
        boolean result = false;
        if (name != null) {
            // 根据联系人姓名删除联系人
            result = db.delete(PERSON_TABLE_NAME, "name = ?", new String[]{name}) > 0;
        }else if (userId != null) {
            // 根据userId删除该用户下的所有联系人
            result = db.delete(PERSON_TABLE_NAME, "user_id = ?", new String[]{userId.toString()}) > 0;
        }
        return result;
    }

    /**
     * 新增用户
     * @param user
     * @return
     */
    public boolean insertUser(User user) {
        // 获取可读写的数据库连接实例
        SQLiteDatabase db = getWritableDatabase();
        ContentValues values = new ContentValues();
        values.put("account", user.getAccount());
        values.put("password", user.getPassword());
        return db.insert(USER_TABLE_NAME, null, values) > 0;
    }

    /**
     * 删除用户
     * @param userId
     * @return
     */
    public boolean deleteUser(Integer userId) {
        // 获取可读写的数据库连接实例
        SQLiteDatabase db = getWritableDatabase();
        return db.delete(USER_TABLE_NAME, "user_id = ?", new String[]{userId.toString()}) > 0;
    }

    /**
     * 更新用户
     * @param user
     * @return
     */
    public boolean updateUser(User user) {
        // 获取可读写的数据库连接实例
        SQLiteDatabase db = getWritableDatabase();
        ContentValues values = new ContentValues();
        values.put("account", user.getAccount());
        values.put("password", user.getPassword());
        return db.update(USER_TABLE_NAME, values, "user_id = ?", new String[]{user.getUserId().toString()}) > 0;
    }

    /**
     * 根据用户名查询用户信息
     * @param account
     * @return
     */
    public User queryUserByAccount(String account) {
        // 获取只读的数据库连接实例
        SQLiteDatabase db = getReadableDatabase();
        Cursor cursor = db.query(USER_TABLE_NAME, null, "account = ?", new String[]{account}, null, null, null);
        User user = new User();
        if (cursor != null && cursor.moveToFirst()) {
            @SuppressLint("Range") Integer userId = cursor.getInt(cursor.getColumnIndex("user_id"));
            @SuppressLint("Range") String account1 = cursor.getString(cursor.getColumnIndex("account"));
            @SuppressLint("Range") String password = cursor.getString(cursor.getColumnIndex("password"));
            user.setUserId(userId);
            user.setAccount(account1);
            user.setPassword(password);
            //System.out.println("userId = " + userId + ", account = " + account1 + ", password = " + password);
            cursor.close();
            return user;
        }
        if (cursor != null) {
            cursor.close();
        }
        return null;
    }


    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
//        更新数据库版本逻辑
        db.execSQL("drop table if exists " + PERSON_TABLE_NAME);
        db.execSQL("drop table if exists " + USER_TABLE_NAME);
        onCreate(db);
    }
}
